package MAIN;
//笔试强训第41天
/*选择题*/
/*有主机的IP和子网掩码然后计算广播号或者网络号，此时先计算哪几个比特位是网络号，
* 哪几个比特位是主机号，（网络号是连续的1，主机号是连续的0）然后进行比特位的计算*/
/*ARP协议的功能是根据IP地址查询MAC地址，当一台设备知道对方的IP地址，不知道对方的MAC
* 地址，启动ARP,发送 ARP request请求广播包到其他主机中，收到广播包的主机查看，只有该
* 请求的设备才会单播回答ARP reply 响应包*/

import netscape.security.UserTarget;

import java.util.Scanner;
import java.util.Stack;

public class Main41 {
    //五子棋
    final public static int N = 20;
    public static void main(String[] args) {
        //循环接收每组测试用例
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            //接收棋谱
            String[] table = new String[N];
            for (int i = 0; i < N; i++) {
                table[i] = scan.next();
                //统计是否存在五子连珠
                System.out.println(sover(table) ? "Yes" : "No");
            }
        }
    }

    private static boolean sover(String[] table) {
        //对棋谱中的每个位置进行检测，如果该位置是棋子，就统计
        //该棋子周围是否存在五子连珠
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (table[i].charAt(j) =='*' ||
                table[i].charAt(j) == '+') {
                    //向（i，j）位置的4个大方向去检测，统计相同颜色棋子的最大个数
                    if (Count(table, i, j, table[i].charAt(j)) >= 5) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    private static int Count(String[] table, int x, int y, char ch) {
        //对棋谱中的每个位置进行检测，如果该位置是棋子，就统计相同颜色棋子的最大个数
        int[][][] direct = {
                {{0,-1},{0,1}},//横向
                {{-1,0},{1,0}},//竖向
                {{-1,-1},{1,1}},//左上到右下
                {{-1,1},{1,-1}},//右上到左下
        };
        int result = 0;
        for (int i = 0; i < 4; i++) {
            //统计单个方向相同棋子的个数
            int c = 0;
            for (int j = 0; j < 2; j++) {
                //将一个大方向分成两个小方向来进行遍历
                int nx = x;
                int ny = y;
                //朝一个方向去统计相同颜色的个数
                while (nx >= 0 && nx < N && ny >= 0 && ny < N && table[nx].charAt(ny) == ch) {
                    c++;
                    nx = nx + direct[i][j][0];
                    ny = ny + direct[i][j][1];
                }
            }
            //返回四个大方向的棋子个数  最后减去1
            result = c > result ? c : result;
        }
        return result - 1;
    }

    //逆波兰表达式求值（后缀表达式求值）
    public static void main1(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            int n = scan.nextInt();
            String s;
            Stack<Integer> stack = new Stack<>();
            for (int i = 0; i < n; i++) {
                s =  scan.next();
                char ch = s.charAt(0);
                if (ch >= '0' && ch <= '9') {
                    //这里转换成整数一定用s，而不是ch，这里如果是两位数此时就不行
                    stack.add(Integer.parseInt(s));
                }else {
                    int right = stack.pop();
                    int left = stack.pop();
                    switch (ch) {
                        case '+':
                            stack.add(left + right);
                            break;
                        case '-':
                            stack.add(left - right);
                            break;
                        case '*':
                            stack.add(left * right);
                            break;
                        case '/':
                            stack.add(left / right);
                            break;
                    }
                }
            }
            System.out.println(stack.pop());
        }
    }
}
